package com.my.ext.utils;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.NameValuePair;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;

import com.alibaba.fastjson.JSONObject;

public class HttpClientUtils {

	private static String charSet = "UTF-8";
	private static CloseableHttpClient httpClient = null;
	private static CloseableHttpResponse response = null;

	public static Map<String,Object> doHttpsPost(String url, byte[] b, Map<String, String> headers) {
		try {
			httpClient = HttpClients.createDefault();//SSLClient.createSSLClientDefault();//
			HttpPost httpPost = new HttpPost(url);
			
			MultipartEntityBuilder mEntityBuilder = MultipartEntityBuilder.create();
			//byte[] postBody
			mEntityBuilder.addBinaryBody("a", b);
			
			Set<Entry<String, String>> entry = headers.entrySet();
			for(Entry<String, String> item : entry) {
				httpPost.setHeader(item.getKey(), item.getValue());
			}
			
			httpPost.setEntity(mEntityBuilder.build());
			response = httpClient.execute(httpPost);
			byte[] content = null;
			if (response != null) {
				HttpEntity resEntity = response.getEntity();
				if (resEntity != null) {
					content = EntityUtils.toByteArray(resEntity);
				}
			}
			Map<String,Object> result = new HashMap<>();
			Header[] respHeaders = response.getAllHeaders();
			for(Header h : respHeaders) {
				System.out.println(" 返回 " + h.getName() + "  :  " + h.getValue());
			}
			result.put("content", content);
			result.put("headers", respHeaders);
			return result;
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return null;
	}
	
	
	public static Map<String,Object> doHttpsPost(String url, Map<String, String> param, Map<String, String> headers) {
		try {
			httpClient = SSLClient.createSSLClientDefault();//HttpClients.createDefault();//
			HttpPost httpPost = new HttpPost(url);
			List<NameValuePair> postParams = new ArrayList<NameValuePair>();
			for (Map.Entry<String, String> entry : param.entrySet()) {
				postParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}
			HttpEntity paramEntity = new UrlEncodedFormEntity(postParams);
			
			httpPost.setEntity(paramEntity);
			response = httpClient.execute(httpPost);
			String content = null;
			if (response != null) {
				HttpEntity resEntity = response.getEntity();
				if (resEntity != null) {
					
					content = EntityUtils.toString(resEntity);
					
				}
			}
			Map<String,Object> result = new HashMap<>();
			Header[] respHeaders = response.getAllHeaders();
			result.put("content", content);
			
			result.put("headers", respHeaders);
			return result;
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return null;
	}

	public static String doHttpsPost(String url, String jsonStr) {
		try {
			httpClient = SSLClient.createSSLClientDefault();
			HttpPost httpPost = new HttpPost(url);
			StringEntity se = new StringEntity(jsonStr);
			httpPost.setEntity(se);
			response = httpClient.execute(httpPost);
			if (response != null) {
				HttpEntity resEntity = response.getEntity();
				if (resEntity != null) {
					return EntityUtils.toString(resEntity, charSet);
				}
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		}
		return null;
	}

	/**
	 * http的post请求(用于key-value格式的参数)
	 * 
	 * @param url
	 * @param param
	 * @return
	 */
	public static String doHttpPost(String url, Map<String, String> param) {
		try {
			// 请求发起客户端
			httpClient = HttpClients.createDefault();
			// 参数集合
			List<NameValuePair> postParams = new ArrayList<NameValuePair>();
			// 遍历参数并添加到集合
			for (Map.Entry<String, String> entry : param.entrySet()) {
				postParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
			}

			// 通过post方式访问
			HttpPost post = new HttpPost(url);
			HttpEntity paramEntity = new UrlEncodedFormEntity(postParams, charSet);
			post.setEntity(paramEntity);
			response = httpClient.execute(post);
			StatusLine status = response.getStatusLine();
			int state = status.getStatusCode();
			if (state == HttpStatus.SC_OK) {
				HttpEntity valueEntity = response.getEntity();
				String content = EntityUtils.toString(valueEntity);
				return content;
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		} catch (ClientProtocolException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * http的post请求（用于请求json格式的参数）
	 * 
	 * @param url
	 * @param params
	 * @return
	 */
	public static String doHttpPost(String url, String jsonStr) {
		try {
			httpClient = HttpClients.createDefault();

			// 创建httpPost
			HttpPost httpPost = new HttpPost(url);
			httpPost.setHeader("Accept", "application/json");

			StringEntity entity = new StringEntity(jsonStr, charSet);
			entity.setContentType("text/json");
			entity.setContentEncoding(new BasicHeader("Content-Type", "application/json"));
			httpPost.setEntity(entity);
			// 发送post请求
			response = httpClient.execute(httpPost);
			System.out.println("zhuangtaiis : " + response.getStatusLine().getStatusCode());
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				HttpEntity responseEntity = response.getEntity();
				String jsonString = EntityUtils.toString(responseEntity);
				System.out.println("fanhuishi : " + jsonString);
				return jsonString;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
	
	
	public static String doHttpPost(String url, String jsonStr, Map<String,String> headers) {
		try {
			httpClient =  SSLClient.createSSLClientDefault();//HttpClients.createDefault();

			// 创建httpPost
			HttpPost httpPost = new HttpPost(url);
			httpPost.setHeader("Content-Type", "application/json; charset=UTF-8");
			httpPost.setHeader("Accept-Encoding", "gzip");
			JSONObject obj = JSONObject.parseObject(jsonStr);
			StringEntity entity = new StringEntity(obj.toJSONString(), charSet);
			entity.setContentType("text/json");
			entity.setContentEncoding(new BasicHeader("Content-Type", "application/json"));
			
			Set<Entry<String, String>> entry = headers.entrySet();
			for(Entry<String, String> item : entry) {
				httpPost.setHeader(item.getKey(), item.getValue());
			}
			
			httpPost.setHeader(new BasicHeader("Content-Type", "application/json"));
			httpPost.setEntity(entity);
			// 发送post请求
			response = httpClient.execute(httpPost);
			System.out.println("zhuangtaiis : " + response.getStatusLine().getStatusCode());
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				HttpEntity responseEntity = response.getEntity();
				
				String jsonString = EntityUtils.toString(responseEntity);
				System.out.println("fanhuishi : " + jsonString);
				return jsonString;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * http的Get请求
	 * 
	 * @param url
	 * @param param
	 * @return
	 */
	public static String doHttpGet(String url, Map<String, String> param) {
		CloseableHttpClient httpclient = null;
		CloseableHttpResponse response = null;

		try {
			httpclient = HttpClients.createDefault();
			if (param != null && !param.isEmpty()) {
				// 参数集合
				List<NameValuePair> getParams = new ArrayList<NameValuePair>();
				for (Map.Entry<String, String> entry : param.entrySet()) {
					getParams.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
				}
				url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(getParams), "UTF-8");
			}
			// 发送gey请求
			HttpGet httpGet = new HttpGet(url);
			response = httpclient.execute(httpGet);
			if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
				return EntityUtils.toString(response.getEntity());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

}